package function

object TestBibao {
  def main(args:Array[String]):Unit= {
    def add(a: Int, b: Int): Int = {
      a + b
    }

    //固定一个加数的场景
def addByFour(b: Int): Int = {
  4 + b
}

    //扩展固定加数改变的情况
    def addByFive(b: Int): Int = {
      5 + b
    }

    //将固定加数作为另一个参数传入
    def addByFour1(a: Int): Int => Int = {
      //      val a=4
      def addB(b: Int): Int = {
        a + b
      }

      addB
    }

    println(addByFour1(34)(3))

    //闭包：内层函数用到了外层函数的一个参数
    //柯里化
    def addCurrying(a: Int)(b: Int): Int = {
      a + b
    }

    println(addCurrying(23)(34))

    //递归
    def digui(a: Int): Int = {
      if (a == 0) 1 else digui(a - 1) * a
    }

    println(digui(5))

    def f2(a: Int): Unit = {
      println("a" + a)
      println("a" + a)
    }

    //用闭包将一个函数作为代码块传入调用
    def myWhile(condition: => Boolean): (=> Unit) => Unit = {
      //内层函数粗腰递归调用，参数就是循环体
      def doloop(op: => Unit): Unit = {
        if (condition) {
          op
          myWhile(condition)(op)
        }
      }

      doloop _

    }

    var n = 10
    myWhile(n>=1)({
      println(n)
      n -= 1
    })

    lazy val result:Int=sum(12,23)
    println("1.函数调用")
    println("2。result="+result)

  }
  def sum(a:Int,b:Int):Int={
    println("3.sum函数调用")
    a+b
  }
  //层级包




}
